Components, such as an application and an add-in, which may correspond to programs such as a word-processing program and a spell-checker, respectively, are easily integrated in a static environment. The reason is that in such a scenario a developer knows, a priori, which components interact well together. For example, the developer may know a priori that a word processing program interacts well with a particular spell-checker. Such components, then, can be easily bound at build time.
However, the problem becomes more difficult when dynamic binding is desired. Put another way, dynamic binding of components at runtime presents more difficult problems because of issues such as versioning of components and their mutual isolation. With respect to versioning, different versions of components often time leads to their incompatibility. For example, version 1.0 of an application may interact correctly with version 1.0 of an add-in. However, if the versioning is off, for example, if the application was upgraded to version 2.0 but the add-in remained at version 1.0, the two components may not work well together—or may not work at all.
The second problem leads to issues with the isolation of the components. For example, if the aforementioned application is integrated with the add-in, upgrading either component may prove difficult or impossible. Thus, if a computer user wants to upgrade an application to version 2.0 but is content with version 1.0 of the add-in, such a user may have a difficult time separating the two applications without breaking apart the integrated system.
To solve at least these two exemplary problems, that is, versioning and isolation, a dynamic binding system would be desirable whereby different versions of components can be used with each other, and where such components could be isolated from each other to such an extent that they don't affect one another when they are disintegrated. Moreover, it would be desirable to provide a managed automation programming model which could allow for dynamic binding of components at runtime, thus allowing these components to communicate in a managed code platform.